source fct_joueur.tcl

###################################
#Accesseur Asteroide
# 0 Num�o
# 1 posX
# 2 posY
# 3 angle
# 4 vitesse
# 5 posX_init
# 6 posY_init
# 7 heure_cr�tion
# 8 liste_joueurs
#

proc get_asteroide_numero {ast} {
    return [lindex $ast 0]
}

proc get_asteroide_posX {ast} {
    return [lindex $ast 1]
}

proc get_asteroide_posY {ast} {
    return [lindex $ast 2]
}

proc get_asteroide_angle {ast} {
    return [lindex $ast 3]
}

proc get_asteroide_vitesse {ast} {
    return [lindex $ast 4]
}

proc get_asteroide_posX_init {ast} {
    return [lindex $ast 5]
}

proc get_asteroide_posY_init {ast} {
    return [lindex $ast 6]
}

proc get_asteroide_heure_creation {ast} {
    return [lindex $ast 7]
}

proc get_asteroide_liste_joueur {ast} {
    return [lindex $ast 8]
}

###################################
# Mutateur Asteroide
# 0 Num�o
# 1 posX
# 2 posY
# 3 angle
# 4 vitesse
# 5 posX_init
# 6 posY_init
# 7 heure_cr�tion
# 8 liste_joueurs
#
proc set_asteroide_numero {ast value} {
    upvar $ast x
    set x [lreplace $x 0 0 $value]
}

proc set_asteroide_posX {ast value} {
    upvar $ast x
    set x [lreplace $x 1 1 $value]
}

proc set_asteroide_posY {ast value} {
    upvar $ast x
    set x [lreplace $x 2 2 $value]
}

proc set_asteroide_angle {ast value} {
    upvar $ast x
    set x [lreplace $x 3 3 $value]
}
proc set_asteroide_vitesse {ast value} {
    upvar $ast x
    set x [lreplace $x 4 4 $value]
}
proc set_asteroide_posX_init {ast value} {
    upvar $ast x
    set x [lreplace $x 5 5) $value]
}
proc set_asteroide_posY_init {ast value} {
    upvar $ast x
    set x [lreplace $x 6 6 $value]
}
proc set_asteroide_heure_creation{ast value} {
    upvar $ast x
    set x [lreplace $x 7 7 $value]
}
proc set_asteroide_liste_joueurs {ast value} {
    upvar $ast x
    set x [lreplace $x 8 8 $value]
}

##################################################################################################
# cette procedure ajoute un joueur dans une liste des joueurs d'un asteroide
# ne fait rien si l'asteroide est deja present dans la table
# ne fait rien si le joueur est deja present dans la liste

proc ajouter_joueur_ast {numero_ast joueur} {
    global table_ast
    global _debug
    
    # recupere l'indice du dernier element de la liste cad celui de la liste des joueurs
    set indice_liste_joueurs [expr [llength [lindex [lindex $table_ast 0] 0] ] -1]
    set trouve_ast 0
    set index_ast 0
    
    # on cherche à savoir grace a son nom si l'asteroide est présent dans la table
    # des qu'on le trouve on arrete la boucle
    # on suppose donc que la table ne comporte pas de doublon
    foreach i [lindex $table_ast 0] {
        set tmp [lsearch [lindex $i 0] $numero_ast]
        if {$tmp <= -1} {
            set index_ast [expr $index_ast + 1]
        } else {
            set trouve_ast 1
            break
        }
    }
    
    # si l'asteroide est trouve on regarde si le joueur n'est pas deja present dans la liste des
    #joueurs de l'asteroide
    # si il n'est pas present on l'ajoute
    if {$trouve_ast == 1} {
        set liste_joueurs_asteroide [lindex [lindex [lindex $table_ast 0] $index_ast] $indice_liste_joueurs]
        set test_doublon [lsearch $liste_joueurs_asteroide $joueur]
        if {$test_doublon == -1} {
            set tmp [linsert $liste_joueurs_asteroide 0 $joueur]
            lset table_ast 0 $index_ast $indice_liste_joueurs $tmp
            if {$_debug == 1} {
                puts "--------- Ajout du joueur $joueur dans l'asteroide $numero_ast ---------"
            }
        } else {
                if {$_debug == 1} {
                    puts "!!!!! Joueur $joueur deja present dans l'asteroide $numero_ast !!!!!!"
                }
        }
    } else {
            if {$_debug == 1} {
                puts "!!!!! L'asteroide $numero_ast n'est pas present dans la table !!!!!!"
            }
    }
}

########################################################################################
########################################################################################
# ajoute un asteroide à la table des asteroides si celui ci n'y est pas deja present
# l'asteroide passe en argument doit etre de la forme
# {numero posX posY angle vitesse {liste_joueurs}}
# ex de construction prealable:
# 		set nouveau_ast [list 44444 12,6 55 12 10 [list J10 J2 J3 J9]]
# 		ajouter_table_ast $nouveau_ast

proc ajouter_table_ast {nouveau_ast} {
    global table_ast
    global _debug
    
    set numero_ast [get_asteroide_numero $nouveau_ast]
    set trouve_ast 0
    
    foreach i [lindex $table_ast 0] {
        set tmp [lsearch [lindex $i 0] $numero_ast]
        if {$tmp > -1} {
            set trouve_ast 1
            break
        }
    }
    if {$trouve_ast == 0} {
        set table_ast [list [linsert [lindex $table_ast 0] end $nouveau_ast]]
        if {$_debug == 1} {
            puts "--------- Ajout de l'asteroide $numero_ast ---------"
        }
    } else {
        if {$_debug == 1} {
           puts "!!!!! L'asteroide $numero_ast est deja présent !!!!"
        }
    }
    
}


#######################################################################################
# Supprime l'ast de la table_ast en fonction de son Numero
#

proc supprimer_ast {ast_Numero} {
    global table_ast
    global _debug
    
    set ast_trouve 0
    #calcul de la longueur de table_aste ou nombre d'astéroides -1 =>  (comme les indices partent de 0)
    set longueur_liste [llength [lindex $table_ast 0]]
    
    #si la table_ast n'est pas vide on cherche la liste contenant ast_Numero à supprimer
    if {$longueur_liste >= 1} {
        set j 0
        foreach i [lindex $table_ast 0] {
            #on cherche ast_Numero dans la liste
            set tmp [lsearch [lindex $i 0] $ast_Numero]
            incr j
            #ast_Numero trouvé alors on supprime la liste correspondante à son numéro
            if {$tmp == 0} {
                set table_ast [list [lreplace [lindex $table_ast 0] [expr $j - 1] [expr $j- 1]]]
                set ast_trouve 1
            }
        }
        
    }
    if {$ast_trouve == 1 && $_debug == 1} {
        puts "--------- asteroide n° $ast_Numero effacé --------- "
    } else {
        if {$_debug == 1} {
           puts " !!!!!!!! l'asteroide n° $ast_Numero n'est pas dans la table !!!!!!!"
        }
    }
    
}

#Entrée : une astéroïde de la table des astéroïdes
#Sortie : rien
#
#Comportement : recalcule la position de l'astéroïde en fonction de son angle et de sa vitesse
proc calcul_position_ast {ast} {
    
    #Attribution de variable
    set X0 [get_asteroide_posX_init $ast]
    set Y0 [get_asteroide_posY_init $ast]
    set alpha [get_asteroide_angle $ast]
    set v [get_asteroide_vitesse $ast]
    
    set dt [expr [clock clicks -milliseconds] - [get_asteroide_heure_creation $ast] ]
   
    set_asteroide_posX ast [expr $X0 + cos($alpha) * $v * $dt / 100]
    set_asteroide_posY ast [expr $Y0 + sin($alpha) * $v * $dt / 100 ]
    
    return $ast
}

proc creation_ast {} {
    global table_ast
    global table_joueurs
    global coef_posX_init
    global coef_posY_init
    global coef_angle
    global coef_vitesse
    global _debug
    global distance_mini
	global compteur_ast
    
	set num_soi_meme [get_joueur_numero [lindex [lindex $table_joueurs 0] 0]]
	incr compteur_ast
    set nouveau_num_ast "$num_soi_meme$compteur_ast"
    
    set posX_init [expr [expr [expr [expr [expr rand() ] * 2] - 1] * [expr $distance_mini + $coef_posX_init]] + [get_joueur_posX [lindex $table_joueurs 0 0] ] ]
    set posY_init [expr [expr [expr [expr [expr rand() ] * 2] - 1] * [expr $distance_mini +$coef_posY_init]] + [get_joueur_posY [lindex $table_joueurs 0 0] ] ]
    set pi [expr {acos(-1)}]
    set angle [expr [expr rand()] * $coef_angle * $pi / 180]
    
    # vitesse: correspond la vitesse du joueur +/- une petite valeur

    set vitesse_joueur [get_joueur_vitesse [lindex $table_joueurs 0 0] ]
    set tmp [expr rand()]
    set tmp_vitesse [expr rand()]
    if {$tmp >=0.5} {
        set nouvelle_vitesse [expr $vitesse_joueur + [expr $tmp_vitesse * $vitesse_joueur * $coef_vitesse]]
    } else {
        set nouvelle_vitesse [expr $vitesse_joueur - [expr $tmp_vitesse * $vitesse_joueur * $coef_vitesse]]
    }
    set nouvel_ast [list $nouveau_num_ast $posX_init $posY_init $angle $nouvelle_vitesse $posX_init $posY_init [clock clicks -milliseconds] [list $num_soi_meme]]
    if {$_debug == 1} {
        puts "------- Cr�tion de l'asteroide $nouveau_num_ast ---------"
    }
    return $nouvel_ast
}

#######################################################################################
# Supprime un joueur de la liste des joueurs de l'asteroide passe en argument
#
proc supprimer_j_ast {numero_joueur numero_asteroide} {
	global table_ast
	global _debug
	
	set ast_trouve -1
	set ast_index 0
	foreach i [lindex $table_ast 0] {
		set tmp [lsearch [lindex $i 0] $numero_asteroide]
		if {$tmp == 0} {
			set ast_trouve $ast_index
		}
		incr ast_index
	}
	
	if {$ast_trouve != -1} {
		set nouv_ast [lindex [lindex $table_ast 0] $ast_trouve]
		set liste_joueurs [get_asteroide_liste_joueur $nouv_ast]
		set compt_joueur 0
		foreach i $liste_joueurs {
			if {$i == $numero_joueur} {
				set liste_joueurs [lreplace $liste_joueurs $compt_joueur $compt_joueur]
			}
			incr compt_joueur
		}
		set nouv_ast [lreplace $nouv_ast 8 8 $liste_joueurs]
		set table_ast [list [lreplace [lindex $table_ast 0] $ast_trouve $ast_trouve $nouv_ast]]
	} else {
		puts "L'astéroïde $numero_asteroide n'existe pas !"
	}
}
